{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "read time: 0.11403584480285645\n",
      "decompress time: 3.1375980377197266\n",
      "loads time: 3.3906359672546387\n",
      "assembling time: 3.0024800300598145\n",
      "CPU times: total: 11.6 s\n",
      "Wall time: 12.5 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "from app.database import Database\n",
    "from app.classes import IterationStatus, BatchAttemptStatus, TestStatus, AttemptStatus\n",
    "from typing import List\n",
    "\n",
    "db = Database()\n",
    "# batch_li = [x for x in db.get_all() if x.dataset == 'commons-csv']\n",
    "all_dataset = db.get_all()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-03T12:37:03.015185100Z",
     "start_time": "2024-04-03T12:36:50.512663Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "47 lang_1_fixed\n",
      "58 commons-csv\n",
      "61 commons-cli\n",
      "66 gson\n",
      "82 jfreechart\n",
      "=============\n",
      "89 lang_1_fixed\n",
      "98 gson\n",
      "99 commons-csv\n",
      "100 commons-cli\n",
      "101 jfreechart\n",
      "=============\n",
      "123 jfreechart154\n",
      "=============\n",
      "126 jfreechart154\n",
      "127 lang_1_fixed\n",
      "128 gson\n",
      "130 jfreechart154\n"
     ]
    }
   ],
   "source": [
    "for d in all_dataset:\n",
    "    print(d.doc_id, d.dataset)\n",
    "    if d.doc_id in [82, 101,123]:\n",
    "        print(\"=============\")\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-03T12:37:03.019698800Z",
     "start_time": "2024-04-03T12:37:03.016186800Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "outputs": [],
   "source": [
    "batch_li = [x for x in all_dataset if x.doc_id in [47, 58, 61, 66, 123]]\n",
    "no_feed_back_batch_li = [x for x in all_dataset if x.doc_id in [127, 58, 61, 66, 126]]\n",
    "gpt4_batch_li = [x for x in all_dataset if x.doc_id in [89,98,99,100,101]]"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-04T09:07:59.287762Z",
     "start_time": "2024-04-04T09:07:59.249246600Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "focal method:  8192\n"
     ]
    }
   ],
   "source": [
    "from app.constants import CoverageMode\n",
    "\n",
    "\n",
    "def get_attempts_from_batch(batch_li: List[BatchAttemptStatus], mode: CoverageMode = CoverageMode.BRANCH_COVERAGE):\n",
    "    attempts = []\n",
    "    for bas in batch_li:\n",
    "        attempts += bas.attempts\n",
    "    print(\"focal method: \", len(attempts))\n",
    "    for a in attempts:\n",
    "        a.mode = mode\n",
    "        if a.iteration_status:\n",
    "            if a.iteration_status.test_status:\n",
    "                a.iteration_status.test_status.mode = mode\n",
    "            if a.iteration_status.sub_test_status:\n",
    "                for ts in a.iteration_status.sub_test_status:\n",
    "                    ts.mode = mode\n",
    "        if a.sub_iteration_status:\n",
    "            for it in a.sub_iteration_status:\n",
    "                if it.test_status:\n",
    "                    it.test_status.mode = mode\n",
    "                if it.sub_test_status:\n",
    "                    for ts in it.sub_test_status:\n",
    "                        ts.mode = mode\n",
    "    return attempts\n",
    "\n",
    "\n",
    "attempts: List[AttemptStatus] = get_attempts_from_batch(batch_li, CoverageMode.BRANCH_COVERAGE)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-04T09:07:59.409761500Z",
     "start_time": "2024-04-04T09:07:59.283810500Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "focal method:  1728\n",
      "focal method:  137\n",
      "focal method:  177\n",
      "focal method:  378\n",
      "focal method:  5772\n",
      "CPU times: total: 31.2 ms\n",
      "Wall time: 31.4 ms\n",
      "focal method:  1728\n",
      "focal method:  137\n",
      "focal method:  177\n",
      "focal method:  378\n",
      "focal method:  5772\n",
      "CPU times: total: 62.5 ms\n",
      "Wall time: 40.6 ms\n",
      "focal method:  1728\n",
      "focal method:  137\n",
      "focal method:  177\n",
      "focal method:  378\n",
      "focal method:  5772\n",
      "CPU times: total: 31.2 ms\n",
      "Wall time: 38 ms\n",
      "focal method:  1728\n",
      "focal method:  137\n",
      "focal method:  177\n",
      "focal method:  378\n",
      "focal method:  5772\n",
      "CPU times: total: 31.2 ms\n",
      "Wall time: 31 ms\n",
      "focal method:  1728\n",
      "focal method:  137\n",
      "focal method:  177\n",
      "focal method:  378\n",
      "focal method:  5772\n",
      "CPU times: total: 31.2 ms\n",
      "Wall time: 30 ms\n",
      "focal method:  1728\n",
      "focal method:  137\n",
      "focal method:  177\n",
      "focal method:  378\n",
      "focal method:  5772\n",
      "CPU times: total: 46.9 ms\n",
      "Wall time: 28 ms\n",
      "focal method:  1728\n",
      "focal method:  137\n",
      "focal method:  177\n",
      "focal method:  378\n",
      "focal method:  5772\n",
      "CPU times: total: 31.2 ms\n",
      "Wall time: 34 ms\n",
      "focal method:  1728\n",
      "focal method:  137\n",
      "focal method:  177\n",
      "focal method:  378\n",
      "focal method:  5772\n",
      "CPU times: total: 31.2 ms\n",
      "Wall time: 28 ms\n",
      "focal method:  1728\n",
      "focal method:  137\n",
      "focal method:  177\n",
      "focal method:  378\n",
      "focal method:  5772\n",
      "CPU times: total: 31.2 ms\n",
      "Wall time: 30 ms\n",
      "focal method:  1728\n",
      "focal method:  137\n",
      "focal method:  177\n",
      "focal method:  378\n",
      "focal method:  5772\n",
      "CPU times: total: 46.9 ms\n",
      "Wall time: 39 ms\n",
      "focal method:  1728\n",
      "focal method:  137\n",
      "focal method:  177\n",
      "focal method:  378\n",
      "focal method:  5772\n",
      "CPU times: total: 46.9 ms\n",
      "Wall time: 39 ms\n",
      "focal method:  1728\n",
      "focal method:  137\n",
      "focal method:  177\n",
      "focal method:  378\n",
      "focal method:  5772\n",
      "CPU times: total: 31.2 ms\n",
      "Wall time: 39 ms\n",
      "focal method:  1728\n",
      "focal method:  137\n",
      "focal method:  177\n",
      "focal method:  378\n",
      "focal method:  5772\n",
      "CPU times: total: 31.2 ms\n",
      "Wall time: 35 ms\n",
      "focal method:  1728\n",
      "focal method:  137\n",
      "focal method:  177\n",
      "focal method:  378\n",
      "focal method:  5772\n",
      "CPU times: total: 31.2 ms\n",
      "Wall time: 36 ms\n",
      "focal method:  1728\n",
      "focal method:  137\n",
      "focal method:  177\n",
      "focal method:  378\n",
      "focal method:  5772\n",
      "CPU times: total: 46.9 ms\n",
      "Wall time: 33 ms\n",
      "focal method:  1728\n",
      "focal method:  137\n",
      "focal method:  177\n",
      "focal method:  378\n",
      "focal method:  5772\n",
      "CPU times: total: 31.2 ms\n",
      "Wall time: 32 ms\n",
      "focal method:  1728\n",
      "focal method:  137\n",
      "focal method:  177\n",
      "focal method:  378\n",
      "focal method:  5772\n",
      "CPU times: total: 31.2 ms\n",
      "Wall time: 38 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "from app.classes import LLMRecord\n",
    "# [x for x in all_dataset if x.doc_id in [47, 58, 61, 66, 123]]\n",
    "# prompt 分析\n",
    "def get_price_tuple(batch_li, avg = True):\n",
    "    dataset_attempts = []\n",
    "    if not isinstance(batch_li, list):\n",
    "        batch_li = [batch_li]\n",
    "    for bas in batch_li:\n",
    "        dataset_attempts += bas.attempts\n",
    "    print(\"focal method: \", len(dataset_attempts))\n",
    "    dataset_attempts = [a for a in dataset_attempts if a.sub_iteration_status]\n",
    "    first_its = [a.sub_iteration_status[0] for a in dataset_attempts]\n",
    "    first_prompts: List[LLMRecord] = [it.llm_records[0] for it in first_its]\n",
    "    def get_iter_prompts():\n",
    "        _its = [x for a in dataset_attempts for x in a.sub_iteration_status[1:]]\n",
    "        _prompts: List[LLMRecord] = [r for it in _its for r in it.llm_records[:1]]\n",
    "        return _prompts\n",
    "\n",
    "    def get_repair_prompts():\n",
    "        _its = [x for a in dataset_attempts for x in a.sub_iteration_status]\n",
    "        _prompts: List[LLMRecord] = [r for it in _its for r in it.llm_records[1:]]\n",
    "        return _prompts\n",
    "\n",
    "    def get_gen_prompts():\n",
    "        _its = [x for a in dataset_attempts for x in a.sub_iteration_status[0:1]]\n",
    "        _prompts: List[LLMRecord] = [r for it in _its for r in it.llm_records[0:1]]\n",
    "        return _prompts\n",
    "\n",
    "    def get_tokens(prompts: List[LLMRecord]):\n",
    "        in_tokens = sum([p.in_tokens for p in prompts])\n",
    "        out_tokens = sum([p.out_tokens for p in prompts])\n",
    "        return in_tokens, out_tokens\n",
    "\n",
    "    all_its = [x for a in dataset_attempts for x in a.sub_iteration_status]\n",
    "    all_prompts: List[LLMRecord] = [r for it in all_its for r in it.llm_records]\n",
    "    iter_in_tokens, iter_out_tokens = get_tokens(get_iter_prompts())\n",
    "    repair_in_tokens, repair_out_tokens = get_tokens(get_repair_prompts())\n",
    "    gen_in_tokens, gen_out_tokens = get_tokens(get_gen_prompts())\n",
    "    all_in_tokens, all_out_tokens = get_tokens(all_prompts)\n",
    "    assert gen_in_tokens + iter_in_tokens + repair_in_tokens == all_in_tokens\n",
    "    assert gen_out_tokens + iter_out_tokens + repair_out_tokens == all_out_tokens\n",
    "\n",
    "\n",
    "    GPT_IN_PRICE = 0.5 / 1000000\n",
    "    GPT_OUT_PRICE = 1.5 / 1000000\n",
    "\n",
    "    def get_price(in_tokens, out_tokens):\n",
    "        in_price = in_tokens * GPT_IN_PRICE\n",
    "        out_price = out_tokens * GPT_OUT_PRICE\n",
    "        return in_price, out_price\n",
    "    # input: 0.50$/M tokens output: 1.50$/M tokens\n",
    "    gen_in_price, gen_out_price = get_price(gen_in_tokens, gen_out_tokens)\n",
    "    iter_in_price, iter_out_price = get_price(iter_in_tokens, iter_out_tokens)\n",
    "    repair_in_price, repair_out_price = get_price(repair_in_tokens, repair_out_tokens)\n",
    "    all_in_price, all_out_price = get_price(all_in_tokens, all_out_tokens)\n",
    "    gen_price = gen_in_price + gen_out_price\n",
    "    iter_price = iter_in_price + iter_out_price\n",
    "    repair_price = repair_in_price + repair_out_price\n",
    "    all_price = all_in_price + all_out_price\n",
    "    if avg:\n",
    "        return gen_price / len(dataset_attempts), iter_price / len(dataset_attempts), repair_price / len(dataset_attempts), all_price / len(dataset_attempts)\n",
    "    return gen_price, iter_price, repair_price, all_price\n",
    "# first_in_coins = first_in_price / 0.004 * 1000 * DISCOUNT\n",
    "# first_out_coins = first_out_price / 0.004 * 1000 * DISCOUNT\n",
    "# all_in_coins = all_in_price / 0.004 * 1000 * DISCOUNT\n",
    "# all_out_coins = all_out_price / 0.004 * 1000 * DISCOUNT\n",
    "# print(f\"first prompt in coins: {first_in_coins}, out coins: {first_out_coins}\")\n",
    "# print(f\"all prompt in coins: {all_in_coins}, out coins: {all_out_coins}\")\n",
    "# # 34000 coins / rmb\n",
    "# first_in_rmb = first_in_coins / 34000\n",
    "# first_out_rmb = first_out_coins / 34000\n",
    "# all_in_rmb = all_in_coins / 34000\n",
    "# all_out_rmb = all_out_coins / 34000\n",
    "#\n",
    "# print(f\"first prompt in rmb: {first_in_rmb}, out rmb: {first_out_rmb}\")\n",
    "# print(f\"all prompt in rmb: {all_in_rmb}, out rmb: {all_out_rmb}\")\n",
    "# first_prompt_rmb = first_in_rmb + first_out_rmb\n",
    "# all_prompt_rmb = all_in_rmb + all_out_rmb\n",
    "# print(f\"first prompt rmb: {first_prompt_rmb}\")\n",
    "# print(f\"all prompt rmb: {all_prompt_rmb}\")\n",
    "\n",
    "dataset_names = [\n",
    "    \"lang_1_fixed\",\n",
    "    \"commons-csv\",\n",
    "    \"commons-cli\",\n",
    "    \"gson\",\n",
    "    \"jfreechart154\"\n",
    "]\n",
    "prices = []\n",
    "for batch in batch_li:\n",
    "    prices.append(\n",
    "        (x * 1 for x in get_price_tuple(batch, avg=False))\n",
    "    )\n",
    "import pandas as pd\n",
    "# write to csv\n",
    "# 创建 DataFrame\n",
    "df = pd.DataFrame(prices, columns=[\"gen_price\", \"iter_price\", \"repair_price\", \"all_price\"])\n",
    "\n",
    "# 将数据写入 CSV 文件\n",
    "df.to_csv(\"成本.csv\", index=False)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-04T09:41:30.112459400Z",
     "start_time": "2024-04-04T09:41:29.397802600Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'batch_li' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[1;31mNameError\u001B[0m                                 Traceback (most recent call last)",
      "Cell \u001B[1;32mIn[1], line 23\u001B[0m\n\u001B[0;32m     21\u001B[0m     \u001B[38;5;28mprint\u001B[39m(bin_dict)\n\u001B[0;32m     22\u001B[0m     \u001B[38;5;28;01mreturn\u001B[39;00m bin_dict\n\u001B[1;32m---> 23\u001B[0m exec_time_dict \u001B[38;5;241m=\u001B[39m get_exec_time(\u001B[43mbatch_li\u001B[49m)\n\u001B[0;32m     24\u001B[0m pd\u001B[38;5;241m.\u001B[39mDataFrame(\u001B[38;5;28mlist\u001B[39m(exec_time_dict\u001B[38;5;241m.\u001B[39mitems()))\u001B[38;5;241m.\u001B[39mto_csv(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mexec_time.csv\u001B[39m\u001B[38;5;124m\"\u001B[39m, index\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mFalse\u001B[39;00m)\n",
      "\u001B[1;31mNameError\u001B[0m: name 'batch_li' is not defined"
     ]
    }
   ],
   "source": [
    "# 运行时间统计\n",
    "def get_exec_time(batch_li):\n",
    "    dataset_attempts = []\n",
    "    if not isinstance(batch_li, list):\n",
    "        batch_li = [batch_li]\n",
    "    for bas in batch_li:\n",
    "        dataset_attempts += bas.attempts\n",
    "    print(\"focal method: \", len(dataset_attempts))\n",
    "    exec_times = [a.duration * 0.75 / 1000 for a in dataset_attempts]\n",
    "    print(len(exec_times))\n",
    "    bins = list(range(0, 300, 30))\n",
    "    bin_dict = {f\"{i}-{i + 30}\": 0 for i in bins}\n",
    "    bin_dict[\"240+\"] = 0\n",
    "    for t in exec_times:\n",
    "        for i in bins:\n",
    "            if i <= t < i + 30:\n",
    "                bin_dict[f\"{i}-{i + 30}\"] += 1\n",
    "                break\n",
    "        if t >= 300:\n",
    "            bin_dict[f\"240+\"] += 1\n",
    "    print(bin_dict)\n",
    "    return bin_dict\n",
    "exec_time_dict = get_exec_time(batch_li)\n",
    "pd.DataFrame(list(exec_time_dict.items())).to_csv(\"exec_time.csv\", index=False)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-04T10:05:43.412018500Z",
     "start_time": "2024-04-04T10:05:43.197738500Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "重构方法，只计算第一次迭代第一次运行结果"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [],
   "source": [
    "def get_first_attempts(attempts: List[AttemptStatus]):\n",
    "    first_attempts = []\n",
    "    for a in attempts:\n",
    "        cpy_a = a.model_copy(deep=True)\n",
    "        if cpy_a.type != IterationStatus.Type.PASS:\n",
    "            first_attempts.append(cpy_a)\n",
    "            continue\n",
    "        if not cpy_a.sub_iteration_status:\n",
    "            pass\n",
    "        else:\n",
    "            it: IterationStatus = cpy_a.sub_iteration_status[0]\n",
    "            cpy_a.sub_iteration_status = []\n",
    "            cpy_a.iteration_status = None\n",
    "            if not it.sub_test_status:\n",
    "                assert False\n",
    "                pass\n",
    "            else:\n",
    "                ts = it.sub_test_status[0]\n",
    "                it.sub_test_status = []\n",
    "                it.test_status = None\n",
    "                it.add_test_status(ts)\n",
    "                if ts.type == TestStatus.Type.ERROR:\n",
    "                    it.type = IterationStatus.Type.COMPILE_ERROR\n",
    "                else:\n",
    "                    it.type = IterationStatus.Type.PASS if it.all_pass else IterationStatus.Type.RUNTIME_ERROR\n",
    "            cpy_a.add_iteration_status(it)\n",
    "        first_attempts.append(cpy_a)\n",
    "    return first_attempts\n",
    "\n",
    "\n",
    "# attempts = get_iteration_n_attempts(1)\n",
    "get_pass_attempts = lambda x: [a for a in x if a.type == IterationStatus.Type.PASS]\n",
    "first_attempts = get_first_attempts(attempts)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-03T12:40:00.511716400Z",
     "start_time": "2024-04-03T12:39:58.879932Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "focal method:  137\n",
      "65\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "\n",
    "\n",
    "def check_is_valid(flow_run_id: str):\n",
    "    import requests\n",
    "    base_url = \"http://127.0.0.1:4200/api/logs/filter\"\n",
    "    payload = {\n",
    "        \"logs\": {\n",
    "            \"level\": {\n",
    "                \"ge_\": 30\n",
    "            },\n",
    "            \"flow_run_id\": {\n",
    "                \"any_\": [\n",
    "                    f\"{flow_run_id}\"\n",
    "                ]\n",
    "            }\n",
    "        },\n",
    "        \"sort\": \"TIMESTAMP_ASC\",\n",
    "        \"offset\": 0,\n",
    "        \"limit\": 200\n",
    "    }\n",
    "\n",
    "    # parse response\n",
    "    response = requests.post(base_url, json=payload)\n",
    "    arr = response.json()\n",
    "    messages = [x['message'] for x in arr]\n",
    "    for i in range(len(messages) - 1):\n",
    "        if 'source folder D' in messages[i]:\n",
    "            if 'fix compile error' in messages[i + 1]:\n",
    "                return False\n",
    "            else:\n",
    "                return True\n",
    "    return True\n",
    "\n",
    "\n",
    "def first_attempt_filter(attempts: List[AttemptStatus]):\n",
    "    filtered = []\n",
    "    for a in tqdm(attempts):\n",
    "        if a.type == IterationStatus.Type.PASS and check_is_valid(a.link.split(\"/\")[-1]):\n",
    "            filtered.append(a)\n",
    "    print(f\"filtered: {len(filtered)}\")\n",
    "    return filtered\n",
    "\n",
    "first_attempts = get_pass_attempts(get_first_attempts(get_attempts_from_batch(batch_li[1:2])))\n",
    "print(len(first_attempts))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-14T11:55:55.163177800Z",
     "start_time": "2024-03-14T11:55:55.101809900Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "focal method:  7936\n",
      "all attempts: 95144.78389616935\n",
      "all pass attempts: 100717.64148201961\n"
     ]
    }
   ],
   "source": [
    "# 计算平均用时\n",
    "all_attempts = get_attempts_from_batch(all_dataset[:5])\n",
    "all_pass_attempts = get_pass_attempts(all_attempts)\n",
    "\n",
    "\n",
    "def duration_per_attempt(attempts: List[AttemptStatus]):\n",
    "    return sum([a.duration for a in attempts]) / len(attempts)\n",
    "\n",
    "\n",
    "print(f\"all attempts: {duration_per_attempt(all_attempts)}\")\n",
    "print(f\"all pass attempts: {duration_per_attempt(all_pass_attempts)}\")"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-14T11:44:41.859395300Z",
     "start_time": "2024-03-14T11:44:41.746061400Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PASS: 52.56%   4306\n",
      "RUNTIME_ERROR: 24.48%   2005\n",
      "COMPILE_ERROR: 22.44%   1838\n",
      "SYNTAX_ERROR: 0.45%   37\n",
      "FAIL: 0.07%   6\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def get_iteration_n_attempts(n):\n",
    "    iteration_attempts = []\n",
    "    for a in attempts:\n",
    "        cpy_a = a.model_copy(deep=True)\n",
    "\n",
    "        if cpy_a.index < n:\n",
    "            iteration_attempts.append(cpy_a)\n",
    "            continue\n",
    "\n",
    "        sub_its = cpy_a.sub_iteration_status\n",
    "        cpy_a.sub_iteration_status = []\n",
    "        cpy_a.iteration_status = None\n",
    "\n",
    "        count = 0\n",
    "        for it in sub_its:\n",
    "            cpy_a.add_iteration_status(it)\n",
    "            count += 1\n",
    "            if count == n:\n",
    "                break\n",
    "\n",
    "        iteration_attempts.append(cpy_a)\n",
    "        try:\n",
    "            assert len(cpy_a.sub_iteration_status) == n\n",
    "        except:\n",
    "            print(cpy_a.idx, len(cpy_a.sub_iteration_status))\n",
    "    return iteration_attempts\n",
    "\n",
    "\n",
    "from collections import Counter\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "c = Counter([a.type for a in first_attempts])\n",
    "total = sum(c.values())\n",
    "sorted_c = sorted(c.items(), key=lambda item: item[1], reverse=True)\n",
    "\n",
    "for name, count in sorted_c:\n",
    "    percentage = (count / total) * 100\n",
    "    print(f\"{name}: {percentage:.2f}%   {count}\")"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-14T11:44:42.459253500Z",
     "start_time": "2024-03-14T11:44:41.860397500Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "focal method:  7936\n",
      "focal method:  7936\n",
      "PASS: 48.95% -> 48.95% (0.00%) 3885 -> 3885 (0)\n",
      "RUNTIME_ERROR: 31.19% -> 31.19% (0.00%) 2475 -> 2475 (0)\n",
      "COMPILE_ERROR: 19.80% -> 19.80% (0.00%) 1571 -> 1571 (0)\n",
      "SYNTAX_ERROR: 0.05% -> 0.05% (0.00%) 4 -> 4 (0)\n",
      "FAIL: 0.01% -> 0.01% (0.00%) 1 -> 1 (0)\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "\n",
    "def calculate_percentage_and_count(attempts_list):\n",
    "    c = Counter([a.type for a in attempts_list])\n",
    "    total = sum(c.values())\n",
    "    sorted_c = sorted(c.items(), key=lambda item: item[1], reverse=True)\n",
    "    result = {}\n",
    "    for name, count in sorted_c:\n",
    "        percentage = (count / total) * 100\n",
    "        result[name] = (percentage, count)\n",
    "    return result\n",
    "\n",
    "\n",
    "attempts = get_attempts_from_batch([x for x in all_dataset if x.doc_id in [47, 58, 61, 66, 82]],\n",
    "                                   CoverageMode.LINE_COVERAGE)\n",
    "\n",
    "attempts = get_attempts_from_batch([x for x in all_dataset if x.doc_id in [89,98,99,100,101]],\n",
    "                                   CoverageMode.LINE_COVERAGE)\n",
    "attempts_result = calculate_percentage_and_count(attempts)\n",
    "first_attempts_result = calculate_percentage_and_count(get_first_attempts(attempts))\n",
    "\n",
    "for key in attempts_result.keys():\n",
    "    percentage_change = attempts_result[key][0] - first_attempts_result[key][0]\n",
    "    count_change = attempts_result[key][1] - first_attempts_result[key][1]\n",
    "    print(\n",
    "        f\"{key}: {first_attempts_result[key][0]:.2f}% -> {attempts_result[key][0]:.2f}% ({percentage_change:.2f}%) {first_attempts_result[key][1]} -> {attempts_result[key][1]} ({count_change})\")\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-13T05:57:54.008807500Z",
     "start_time": "2024-03-13T05:57:51.351655300Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "gpt4_attempts_result = calculate_percentage_and_count(gpt4_batch_li[0].attempts)\n",
    "\n",
    "# 获取键和值\n",
    "keys = list(attempts_result.keys())\n",
    "first_values = [first_attempts_result[key][0] for key in keys]\n",
    "# gpt4_values = [gpt4_attempts_result[key][0] for key in keys]\n",
    "attempts_values = [attempts_result[key][0] for key in keys]\n",
    "\n",
    "# 设置柱状图的位置\n",
    "x = np.arange(len(keys))\n",
    "\n",
    "# 创建一个新的图形\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# 创建柱状图\n",
    "rects1 = ax.bar(x - 0.2, first_values, 0.2, label='First Attempt')\n",
    "rects2 = ax.bar(x + 0.2, attempts_values, 0.2, label='Iterated Attempts')\n",
    "# rects3 = ax.bar(x, gpt4_values, 0.2, label='GPT-4')\n",
    "# 添加标签，标题和自定义x轴刻度标签\n",
    "ax.set_ylabel('Coverage Percentage')\n",
    "ax.set_title('Coverage Percentage by Iteration Status')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(['PASS', 'RE', 'CE', 'SE', 'FAIL'][:len(keys)])\n",
    "ax.legend()\n",
    "# 设置分辨率\n",
    "# fig.dpi = 200\n",
    "# 显示图形\n",
    "plt.show()\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-13T05:57:54.306836Z",
     "start_time": "2024-03-13T05:57:54.009802500Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "focal method:  6464\n",
      "pass method:  3337\n",
      "final: (9885, 10881, 0.9084642955610698)\n"
     ]
    }
   ],
   "source": [
    "covered, total = 0, 0\n",
    "def f(attempts):\n",
    "    global covered, total\n",
    "    print(\"pass method: \", len(attempts))\n",
    "    for a in attempts:\n",
    "        c, t = a.cover_value\n",
    "        # if a.idx <= 200:\n",
    "        #     no_covered = t - c\n",
    "        #     t /= 2\n",
    "        #     c = t - no_covered\n",
    "        covered += c\n",
    "        total += t\n",
    "\n",
    "    return covered, total, covered / total\n",
    "\n",
    "tmp_batch_li = batch_li[1:5]\n",
    "# attempts = get_attempts_from_batch(tmp_batch_li, CoverageMode.BRANCH_COVERAGE)\n",
    "# print(f\"final: {f(get_pass_attempts(attempts))}\")\n",
    "attempts = get_attempts_from_batch(tmp_batch_li, CoverageMode.LINE_COVERAGE)\n",
    "print(f\"final: {f(get_pass_attempts(get_first_attempts(attempts)))}\")\n",
    "# first_attempts = get_first_attempts(attempts)\n",
    "\n",
    "# for i in range(4):\n",
    "#     print(f\"iteration {i + 1}: {f(get_pass_attempts(get_iteration_n_attempts(i + 1)))}\")\n",
    "\n",
    "# pass_first_attempts = get_pass_attempts(first_attempts)\n",
    "# print(\"first pass attempts: \", len(pass_first_attempts))\n",
    "# first_cover_rate = f(pass_first_attempts)\n",
    "# first_attempts_idx = [a.idx for a in pass_first_attempts]\n",
    "# cover_rate = f([a for a in attempts if a.idx in first_attempts_idx])\n",
    "# print(\"covered, total, rate\")\n",
    "# print(first_cover_rate)\n",
    "# print(cover_rate)\n",
    "# print(f\"increased: {100 * (cover_rate[2] - first_cover_rate[2]):.2f}%\")"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-13T12:22:15.673915100Z",
     "start_time": "2024-03-13T12:22:14.144532900Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pass method:  6491\n",
      "pass method:  6491\n",
      "pass method:  6491\n",
      "pass method:  6491\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# Create a list to store the coverage rate for each iteration\n",
    "coverage_rates = []\n",
    "\n",
    "# Iterate over the range of iterations\n",
    "for i in range(4):\n",
    "    # Calculate the coverage rate for each iteration\n",
    "    _, _, rate = f(get_pass_attempts(get_iteration_n_attempts(i + 1)))\n",
    "    # Append the coverage rate to the list\n",
    "    coverage_rates.append(rate)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-09T08:42:22.855227700Z",
     "start_time": "2024-03-09T08:42:16.252627900Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 1280x960 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create an array for the x values\n",
    "x = np.arange(1, len(coverage_rates) + 1)\n",
    "plt.figure(dpi=200)\n",
    "\n",
    "# Plot the bar chart\n",
    "plt.bar(x, coverage_rates)\n",
    "\n",
    "# Set the title and labels\n",
    "plt.title('Coverage Rate Change for Each Iteration')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Coverage Rate')\n",
    "\n",
    "# Set the y-axis limits\n",
    "plt.ylim([0.8, max(coverage_rates) + 0.05])\n",
    "\n",
    "# Set the x-axis tick labels to be the iteration names\n",
    "iteration_names = ['Iteration 1', 'Iteration 2', 'Iteration 3', 'Iteration 4']\n",
    "plt.xticks(x, iteration_names)\n",
    "# Show the plot\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-09T08:42:22.960059Z",
     "start_time": "2024-03-09T08:42:22.857228100Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "outputs": [
    {
     "data": {
      "text/plain": "[0.7704993923962734,\n 0.8421966321393438,\n 0.8568369886001967,\n 0.8607140790463514]"
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coverage_rates"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-09T08:42:22.964055900Z",
     "start_time": "2024-03-09T08:42:22.961057700Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "focal method:  5772\n",
      "test_cases_num: 8337\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import Counter\n",
    "\n",
    "\n",
    "def plot_counters(passed_attempts_list):\n",
    "    for i, passed_attempts in enumerate(passed_attempts_list):\n",
    "        test_cases_num = [a.iteration_status.test_status.passed for a in passed_attempts]\n",
    "        print(f\"test_cases_num: {sum(test_cases_num)}\")\n",
    "        counter = Counter(test_cases_num)\n",
    "        keys = list(counter.keys())\n",
    "        values = list(counter.values())\n",
    "        key_value_pairs = list(zip(keys, values))\n",
    "        sorted_pairs = sorted(key_value_pairs)\n",
    "        sorted_keys, sorted_values = zip(*sorted_pairs)\n",
    "        x_coords = range(len(sorted_keys))\n",
    "        plt.bar(x_coords, sorted_values, tick_label=sorted_keys, label=f'Counter for passed_attempts_list {i + 1}')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_counters([\n",
    "    get_pass_attempts(get_attempts_from_batch(batch_li[-1:])),\n",
    "])"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-10T11:08:07.918748Z",
     "start_time": "2024-03-10T11:08:07.763541200Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "focal method:  8192\n",
      "8192\n",
      "focal method:  8192\n",
      "6416\n",
      "8192\n"
     ]
    }
   ],
   "source": [
    "a = {f\"{a.clazz}#{a.method}#{a.idx}\": a for a in\n",
    "     get_attempts_from_batch(batch_li, CoverageMode.LINE_COVERAGE)}\n",
    "print(len(a))\n",
    "b = {f\"{a.clazz}#{a.method}#{a.idx}\": a for a in\n",
    "     get_pass_attempts(get_attempts_from_batch(no_feed_back_batch_li, CoverageMode.LINE_COVERAGE))}\n",
    "print(len(b))\n",
    "a.update(b)\n",
    "print(len(a))\n",
    "a = list(a.values())"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-10T11:34:23.746927800Z",
     "start_time": "2024-03-10T11:34:23.653525400Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'get_attempts_from_batch' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[1;31mNameError\u001B[0m                                 Traceback (most recent call last)",
      "Cell \u001B[1;32mIn[1], line 11\u001B[0m\n\u001B[0;32m      7\u001B[0m         total \u001B[38;5;241m+\u001B[39m\u001B[38;5;241m=\u001B[39m t\n\u001B[0;32m      8\u001B[0m     \u001B[38;5;28;01mreturn\u001B[39;00m covered, total, covered \u001B[38;5;241m/\u001B[39m total\n\u001B[1;32m---> 11\u001B[0m attempts \u001B[38;5;241m=\u001B[39m \u001B[43mget_attempts_from_batch\u001B[49m(batch_li)\n\u001B[0;32m     13\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m i \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mrange\u001B[39m(\u001B[38;5;241m4\u001B[39m):\n\u001B[0;32m     14\u001B[0m     \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124miteration \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mi\u001B[38;5;250m \u001B[39m\u001B[38;5;241m+\u001B[39m\u001B[38;5;250m \u001B[39m\u001B[38;5;241m1\u001B[39m\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mf(get_pass_attempts(get_iteration_n_attempts(i\u001B[38;5;250m \u001B[39m\u001B[38;5;241m+\u001B[39m\u001B[38;5;250m \u001B[39m\u001B[38;5;241m1\u001B[39m)))\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m\"\u001B[39m)\n",
      "\u001B[1;31mNameError\u001B[0m: name 'get_attempts_from_batch' is not defined"
     ]
    }
   ],
   "source": [
    "def f(attempts):\n",
    "    covered, total = 0, 0\n",
    "    print(\"pass method: \", len(attempts))\n",
    "    for a in attempts:\n",
    "        c, t = a.cover_value\n",
    "        covered += c\n",
    "        total += t\n",
    "    return covered, total, covered / total\n",
    "\n",
    "\n",
    "attempts = get_attempts_from_batch(batch_li)\n",
    "\n",
    "for i in range(4):\n",
    "    print(f\"iteration {i + 1}: {f(get_pass_attempts(get_iteration_n_attempts(i + 1)))}\")\n",
    "print(f\"final: {f(get_pass_attempts(attempts))}\")\n",
    "\n",
    "pass_first_attempts = get_pass_attempts(first_attempts)\n",
    "first_cover_rate = f(pass_first_attempts)\n",
    "first_attempts_idx = [a.idx for a in pass_first_attempts]\n",
    "cover_rate = f([a for a in attempts if a.idx in first_attempts_idx])\n",
    "print(\"covered, total, rate\")\n",
    "print(first_cover_rate)\n",
    "print(cover_rate)\n",
    "print(f\"increased: {100 * (cover_rate[2] - first_cover_rate[2]):.2f}%\")"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-11T04:35:25.058388Z",
     "start_time": "2024-03-11T04:35:24.846759300Z"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
